#pragma once

#include "task_executor.h"
#include "task_template_factory.h"
#include "application/vehicle/vehicle_service.h"
#include "application/dispatcher/dispatcher_service.h"
#include "application/map/map_application_service.h"
#include "infrastructure/services/common_service.h"
#include "infrastructure/configuration/task_config_provider.h"
#include "kernel/task/task_types.h"
#include "kernel/interfaces/Result.h"
#include <QMetaObject>
#include <memory>
#include <string>
#include <vector>
#include <unordered_map>
#include <chrono>
#include <functional>

namespace application {
namespace caller {
    struct CallerMessage;
    class CallerManager;
}

namespace task {

/**
 * @brief 任务服务 - 任务管理的应用层服务
 * @details 对应三方代码中的 TaskManager
 *          Clean Architecture：应用层服务，编排各子系统协作
 *
 *          核心职责：
 *          1. 任务创建与调度（使用DispatcherService选择AGV）
 *          2. 任务链管理（使用TaskExecutor执行）
 *          3. 任务状态查询与控制
 */
class TaskService {
public:
    explicit TaskService(
        std::shared_ptr<vehicle::VehicleService> vehicleService,
        std::shared_ptr<dispatcher::DispatcherService> dispatcherService,
        std::shared_ptr<MapApplicationService> mapService,
        std::shared_ptr<infrastructure::services::CommonService> commonService
    );

    ~TaskService();

    // ==================== 任务创建 ====================

    /**
     * @brief 根据配置模板创建任务
     * @param templateName 模板名称（如 "#6_A2-DB"）
     * @param preferredAgvNumber 优先AGV（-1表示自动选择）
     * @param fromCaller 是否来自呼叫器触发（用于决定是否应用连发/对发检查）
     * @return Result<任务链ID>
     */
    kernel::Result<std::string> createTaskFromTemplate(
        const std::string& templateName,
        int preferredAgvNumber = -1,
        bool fromCaller = false
    );

    /**
     * @brief 获取所有可用的任务模板名称
     * @return 模板名称列表
     */
    std::vector<std::string> getAvailableTemplates() const;

    /**
     * @brief 重新加载任务配置
     * @return 是否成功
     */
    kernel::Result<void> reloadTaskConfig();

    /**
     * @brief 创建移动任务
     * @param targetStation 目标站点
     * @param floor 楼层
     * @param preferredAgvNumber 优先选择的AGV（-1表示自动选择）
     * @return Result<任务链ID>
     */
    kernel::Result<std::string> createMoveTask(
        const std::string& targetStation,
        int floor,
        int preferredAgvNumber = -1
    );

    /**
     * @brief 创建充电任务
     * @param agvNumber AGV编号（-1表示自动选择低电量AGV）
     * @param chargePoint 充电点（空表示自动选择）
     * @param targetBatteryLevel 目标电量百分比
     * @return Result<任务链ID>
     */
    kernel::Result<std::string> createChargeTask(
        int agvNumber = -1,
        const std::string& chargePoint = "",
        int targetBatteryLevel = 100
    );

    /**
     * @brief 创建泊车任务
     * @param agvNumber AGV编号（-1表示自动选择）
     * @param parkingStation 泊车站点（空表示自动选择）
     * @return Result<任务链ID>
     */
    kernel::Result<std::string> createParkTask(
        int agvNumber = -1,
        const std::string& parkingStation = ""
    );

    /**
     * @brief 创建搬运任务（移动 + 顶升上升 + 移动 + 顶升下降）
     * @param pickStation 取货站点
     * @param dropStation 送货站点
     * @param floor 楼层
     * @param preferredAgvNumber 优先AGV
     * @return Result<任务链ID>
     */
    kernel::Result<std::string> createTransportTask(
        const std::string& pickStation,
        const std::string& dropStation,
        int floor,
        int preferredAgvNumber = -1
    );

    // ==================== 任务控制 ====================

    /**
     * @brief 暂停任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    kernel::Result<void> pauseTask(const std::string& chainId);

    /**
     * @brief 恢复任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    kernel::Result<void> resumeTask(const std::string& chainId);

    /**
     * @brief 取消任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    kernel::Result<void> cancelTask(const std::string& chainId);

    /**
     * @brief 重置当前子任务状态
     * @param chainId 任务链ID
     * @return 是否成功
     */
    kernel::Result<void> resetCurrentSubTask(const std::string& chainId);

    /**
     * @brief 手动请求重新调度指定AGV的导航任务
     * @param agvNumber AGV编号
     * @return true=请求已受理，false=失败或AGV不可用
     */
    bool rescheduleAgvTask(int agvNumber);

    // ==================== 任务查询 ====================

    /**
     * @brief 获取所有活跃的任务链ID
     * @return 任务链ID列表
     */
    std::vector<std::string> getActiveTaskIds() const;

    /**
     * @brief 获取指定AGV的任务链ID
     * @param agvNumber AGV编号
     * @return 任务链ID列表
     */
    std::vector<std::string> getTaskIdsByAgv(int agvNumber) const;

    /**
     * @brief 获取任务链状态
     * @param chainId 任务链ID
     * @return 任务链状态（可能为nullptr）
     */
    const TaskChainState* getTaskState(const std::string& chainId) const;

    // ==================== 服务控制 ====================

    /**
     * @brief 启动任务服务
     */
    void start();

    /**
     * @brief 停止任务服务
     */
    void stop();

    /**
     * @brief 获取TaskExecutor（用于信号连接）
     * @return TaskExecutor指针
     */
    TaskExecutor* getExecutor() const { return m_executor.get(); }
    void setPlanningFailureNotifier(std::function<void(const QString&)> notifier) {
        m_planningFailureNotifier = std::move(notifier);
    }

    // ==================== 呼叫器触发任务 ====================

    /**
     * @brief 设置呼叫器触发任务是否启用（维护模式开关）
     * @param enabled true=启用呼叫器触发，false=禁用（维护模式）
     */
    void setCallerTriggerEnabled(bool enabled);

    /**
     * @brief 获取呼叫器触发任务是否启用
     * @return true=启用，false=禁用
     */
    bool isCallerTriggerEnabled() const;

    /**
     * @brief 设置呼叫器连发检查是否启用
     * @param enabled true=启用连发检查（相同任务不允许重复创建），false=禁用
     */
    void setCallerDuplicateCheckEnabled(bool enabled);

    /**
     * @brief 获取呼叫器连发检查是否启用
     * @return true=启用，false=禁用
     */
    bool isCallerDuplicateCheckEnabled() const;

    /**
     * @brief 设置呼叫器对发检查是否启用
     * @param enabled true=启用对发检查（互斥任务不允许同时执行），false=禁用
     */
    void setCallerMutexCheckEnabled(bool enabled);

    /**
     * @brief 获取呼叫器对发检查是否启用
     * @return true=启用，false=禁用
     */
    bool isCallerMutexCheckEnabled() const;

public slots:
    /**
     * @brief 处理呼叫器按钮按下触发的任务创建
     * @param msg 呼叫器消息（包含任务名称等）
     */
    void handleCallerTriggeredTask(const application::caller::CallerMessage& msg);

private:
    std::shared_ptr<vehicle::VehicleService> m_vehicleService;
    std::shared_ptr<dispatcher::DispatcherService> m_dispatcherService;
    std::shared_ptr<MapApplicationService> m_mapService;
    std::shared_ptr<kernel::ILogger> m_logger;

    // 任务执行器
    std::unique_ptr<TaskExecutor> m_executor;

    // 任务配置提供者
    std::shared_ptr<infrastructure::configuration::TaskConfigProvider> m_configProvider;

    // 任务模板工厂
    std::unique_ptr<TaskTemplateFactory> m_templateFactory;
    std::weak_ptr<application::caller::CallerManager> m_callerManager;
    QMetaObject::Connection m_autoChargeConnection;
    std::function<void(const QString&)> m_planningFailureNotifier;

    // 呼叫器触发任务控制
    bool m_callerTriggerEnabled{true};          // 默认启用呼叫器触发
    bool m_callerDuplicateCheckEnabled{true};   // 默认启用呼叫器连发检查（相同任务）
    bool m_callerMutexCheckEnabled{true};       // 默认启用呼叫器对发检查（互斥任务）

    /**
     * @brief 选择低电量AGV
     * @param floor 楼层（-1表示所有楼层）
     * @param batteryThreshold 电量阈值
     * @return AGV编号（-1表示未找到）
     */
    int selectLowBatteryAgv(int floor = -1, int batteryThreshold = 30);

    void handleAutoChargeRequest(int agvNumber,
                                 vehicle::VehicleService::AutoChargeReason reason,
                                 int batteryLevel);
    kernel::Result<void> ensureAgvAvailableForTask(int agvNumber) const;
    kernel::Result<void> ensureTemplateCooldown(const std::string& templateName) const;
    void recordTemplateTrigger(const std::string& templateName);

    std::chrono::seconds m_taskCooldown{std::chrono::seconds(5)};
    mutable std::unordered_map<std::string, std::chrono::system_clock::time_point> m_lastTemplateTriggers;
};

} // namespace task
} // namespace application
